MAYBE 86.92 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/empty.hs
H-Termination of the given Haskell-Program with start terms could not be shown:



HASKELL
  ↳ LR

mainModule Main
  ((enumFromTo :: Ratio Int  ->  Ratio Int  ->  [Ratio Int]) :: Ratio Int  ->  Ratio Int  ->  [Ratio Int])

module Main where
  import qualified Prelude



Lambda Reductions:
The following Lambda expression
\(m,_)→m

is transformed to
m0 (m,_) = m

The following Lambda expression
\(_,r)→r

is transformed to
r0 (_,r) = r

The following Lambda expression
\(q,_)→q

is transformed to
q1 (q,_) = q



↳ HASKELL
  ↳ LR
HASKELL
      ↳ IFR

mainModule Main
  ((enumFromTo :: Ratio Int  ->  Ratio Int  ->  [Ratio Int]) :: Ratio Int  ->  Ratio Int  ->  [Ratio Int])

module Main where
  import qualified Prelude



If Reductions:
The following If expression
if primGEqNatS x y then Succ (primDivNatS (primMinusNatS x y) (Succ y)) else Zero

is transformed to
primDivNatS0 x y True = Succ (primDivNatS (primMinusNatS x y) (Succ y))
primDivNatS0 x y False = Zero

The following If expression
if primGEqNatS x y then primModNatS (primMinusNatS x y) (Succ y) else Succ x

is transformed to
primModNatS0 x y True = primModNatS (primMinusNatS x y) (Succ y)
primModNatS0 x y False = Succ x



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
HASKELL
          ↳ BR

mainModule Main
  ((enumFromTo :: Ratio Int  ->  Ratio Int  ->  [Ratio Int]) :: Ratio Int  ->  Ratio Int  ->  [Ratio Int])

module Main where
  import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.
Binding Reductions:
The bind variable of the following binding Pattern
frac@(Double vy vz)

is replaced by the following term
Double vy vz

The bind variable of the following binding Pattern
frac@(Float ww wx)

is replaced by the following term
Float ww wx



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
HASKELL
              ↳ COR

mainModule Main
  ((enumFromTo :: Ratio Int  ->  Ratio Int  ->  [Ratio Int]) :: Ratio Int  ->  Ratio Int  ->  [Ratio Int])

module Main where
  import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
takeWhile p [] = []
takeWhile p (x : xs)
 | p x
 = x : takeWhile p xs
 | otherwise
 = []

is transformed to
takeWhile p [] = takeWhile3 p []
takeWhile p (x : xs) = takeWhile2 p (x : xs)

takeWhile1 p x xs True = x : takeWhile p xs
takeWhile1 p x xs False = takeWhile0 p x xs otherwise

takeWhile0 p x xs True = []

takeWhile2 p (x : xs) = takeWhile1 p x xs (p x)

takeWhile3 p [] = []
takeWhile3 xy xz = takeWhile2 xy xz



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
HASKELL
                  ↳ LetRed

mainModule Main
  ((enumFromTo :: Ratio Int  ->  Ratio Int  ->  [Ratio Int]) :: Ratio Int  ->  Ratio Int  ->  [Ratio Int])

module Main where
  import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
m
where 
m  = m0 vu6
m0 (m,vv) = m
vu6  = properFraction x

are unpacked to the following functions on top level
truncateM0 yu (m,vv) = m

truncateM yu = truncateM0 yu (truncateVu6 yu)

truncateVu6 yu = properFraction yu

The bindings of the following Let/Where expression
(fromIntegral q,r :% y)
where 
q  = q1 vu30
q1 (q,wz) = q
r  = r0 vu30
r0 (xu,r) = r
vu30  = quotRem x y

are unpacked to the following functions on top level
properFractionQ yv yw = properFractionQ1 yv yw (properFractionVu30 yv yw)

properFractionR yv yw = properFractionR0 yv yw (properFractionVu30 yv yw)

properFractionQ1 yv yw (q,wz) = q

properFractionVu30 yv yw = quotRem yv yw

properFractionR0 yv yw (xu,r) = r



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
HASKELL
                      ↳ NumRed

mainModule Main
  ((enumFromTo :: Ratio Int  ->  Ratio Int  ->  [Ratio Int]) :: Ratio Int  ->  Ratio Int  ->  [Ratio Int])

module Main where
  import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
HASKELL
                          ↳ Narrow
                          ↳ Narrow

mainModule Main
  (enumFromTo :: Ratio Int  ->  Ratio Int  ->  [Ratio Int])

module Main where
  import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primMinusNatS(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS(yx2000, yx2010)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
QDP
                                ↳ DependencyGraphProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(new_primMinusNatS0(yx40000), Zero)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS0(Zero, Zero) → new_primDivNatS(new_primMinusNatS1, Zero)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)
new_primMinusNatS1Zero
new_primMinusNatS0(yx30000) → Succ(yx30000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
QDP
                                    ↳ UsableRulesProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(new_primMinusNatS0(yx40000), Zero)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)
new_primMinusNatS1Zero
new_primMinusNatS0(yx30000) → Succ(yx30000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
QDP
                                        ↳ QReductionProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(new_primMinusNatS0(yx40000), Zero)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)
new_primMinusNatS0(yx30000) → Succ(yx30000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS1
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS1



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
QDP
                                            ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(new_primMinusNatS0(yx40000), Zero)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)
new_primMinusNatS0(yx30000) → Succ(yx30000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(new_primMinusNatS0(yx40000), Zero) at position [0] we obtained the following new rules:

new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(Succ(yx40000), Zero)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
QDP
                                                ↳ UsableRulesProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(Succ(yx40000), Zero)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)
new_primMinusNatS0(yx30000) → Succ(yx30000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
QDP
                                                    ↳ QReductionProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(Succ(yx40000), Zero)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS0(x0)
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS0(x0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
QDP
                                                        ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(Succ(yx40000), Zero)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246)) at position [0] we obtained the following new rules:

new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
QDP
                                                            ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(Succ(yx40000), Zero)
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246))

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(Succ(yx245), Succ(yx246)), Succ(yx246)) at position [0] we obtained the following new rules:

new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
QDP
                                                                ↳ QDPOrderProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(Succ(yx40000), Zero)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_primDivNatS0(Succ(yx40000), Succ(yx41000)) → new_primDivNatS00(yx40000, yx41000, yx40000, yx41000)
new_primDivNatS0(Succ(yx40000), Zero) → new_primDivNatS(Succ(yx40000), Zero)
The remaining pairs can at least be oriented weakly.

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)
Used ordering: Polynomial interpretation [25]:

POL(Succ(x1)) = 1 + x1   
POL(Zero) = 0   
POL(new_primDivNatS(x1, x2)) = x1   
POL(new_primDivNatS0(x1, x2)) = 1 + x1   
POL(new_primDivNatS00(x1, x2, x3, x4)) = x1   
POL(new_primDivNatS01(x1, x2)) = x1   
POL(new_primMinusNatS2(x1, x2)) = x1   

The following usable rules [17] were oriented:

new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ QDPOrderProof
QDP
                                                                    ↳ DependencyGraphProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS(Succ(yx4000), yx4100) → new_primDivNatS0(yx4000, yx4100)
new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)
new_primDivNatS01(yx245, yx246) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))
new_primDivNatS00(yx245, yx246, Succ(yx2470), Zero) → new_primDivNatS(new_primMinusNatS2(yx245, yx246), Succ(yx246))
new_primDivNatS00(yx245, yx246, Zero, Zero) → new_primDivNatS01(yx245, yx246)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ QDPOrderProof
                                                                  ↳ QDP
                                                                    ↳ DependencyGraphProof
QDP
                                                                        ↳ UsableRulesProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)

The TRS R consists of the following rules:

new_primMinusNatS2(Succ(yx2000), Succ(yx2010)) → new_primMinusNatS2(yx2000, yx2010)
new_primMinusNatS2(Zero, Succ(yx2010)) → Zero
new_primMinusNatS2(Zero, Zero) → Zero
new_primMinusNatS2(Succ(yx2000), Zero) → Succ(yx2000)

The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ QDPOrderProof
                                                                  ↳ QDP
                                                                    ↳ DependencyGraphProof
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
QDP
                                                                            ↳ QReductionProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)

R is empty.
The set Q consists of the following terms:

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primMinusNatS2(Zero, Succ(x0))
new_primMinusNatS2(Zero, Zero)
new_primMinusNatS2(Succ(x0), Zero)
new_primMinusNatS2(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ UsableRulesProof
                                                  ↳ QDP
                                                    ↳ QReductionProof
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ QDPOrderProof
                                                                  ↳ QDP
                                                                    ↳ DependencyGraphProof
                                                                      ↳ QDP
                                                                        ↳ UsableRulesProof
                                                                          ↳ QDP
                                                                            ↳ QReductionProof
QDP
                                                                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primDivNatS00(yx245, yx246, Succ(yx2470), Succ(yx2480)) → new_primDivNatS00(yx245, yx246, yx2470, yx2480)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yx2180), Succ(yx212000)) → new_primPlusNat(yx2180, yx212000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ DependencyGraphProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, new_fromInt(Pos(Succ(Zero))), ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map11(yx207, yx212000, bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map18(yx207, bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
QDP
                                    ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, new_fromInt(Pos(Succ(Zero))), ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
QDP
                                        ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, new_fromInt(Pos(Succ(Zero))), ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc) at position [1] we obtained the following new rules:

new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
QDP
                                            ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, new_fromInt(Pos(Succ(Zero))), ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
QDP
                                                ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, new_fromInt(Pos(Succ(Zero))), ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc) at position [1] we obtained the following new rules:

new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
QDP
                                                    ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, new_fromInt(Pos(Succ(Zero))), ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, new_fromInt(Pos(Succ(Zero))), ba) at position [2] we obtained the following new rules:

new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
QDP
                                                        ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map5(yx253, yx252, bb) → new_map7(yx252, new_fromInt(Pos(Succ(Zero))), bb) at position [1] we obtained the following new rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
QDP
                                                            ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map6(yx255, yx254, bb) → new_map19(yx254, new_fromInt(Pos(Succ(Zero))), bb) at position [1] we obtained the following new rules:

new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
QDP
                                                                ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc) at position [3] we obtained the following new rules:

new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
QDP
                                                                    ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
QDP
                                                                        ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
QDP
                                                                            ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
QDP
                                                                                ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc) at position [3] we obtained the following new rules:

new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
QDP
                                                                                    ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
QDP
                                                                                        ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc) at position [1] we obtained the following new rules:

new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
QDP
                                                                                            ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, new_fromInt(Pos(Succ(Zero))), bc) at position [3] we obtained the following new rules:

new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
QDP
                                                                                                ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
QDP
                                                                                                    ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, new_fromInt(Pos(Succ(Zero))), bc) at position [2] we obtained the following new rules:

new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
QDP
                                                                                                        ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, new_fromInt(Pos(Succ(Zero))), bc) at position [1] we obtained the following new rules:

new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
QDP
                                                                                                            ↳ UsableRulesProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_fromInt(yx8) → yx8
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
QDP
                                                                                                                ↳ QReductionProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))
new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt(x0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
QDP
                                                                                                                    ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Succ(yx213000))), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc) we obtained the following new rules:

new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
QDP
                                                                                                                        ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map14(yx207, yx218, Succ(yx21200), yx232, bc) → new_map13(yx207, Succ(new_primPlusNat0(yx218, yx21200)), Succ(new_primPlusNat0(yx218, yx21200)), yx232, Succ(new_primPlusNat0(yx218, yx21200)), yx207, bc) we obtained the following new rules:

new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
QDP
                                                                                                                            ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, yx218, Neg(yx2120), yx219, Pos(yx2130), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc) we obtained the following new rules:

new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Succ(yx2510), bb) → new_map(yx19900, yx249, yx250, yx237, yx2510, yx19900, bb) we obtained the following new rules:

new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                    ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc) we obtained the following new rules:

new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                        ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Neg(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Neg(Zero), yx250, yx2370, bb) we obtained the following new rules:

new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
QDP
                                                                                                                                            ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map10(yx207, yx239, bc) → new_map4(yx207, Zero, Zero, yx239, Zero, bc) we obtained the following new rules:

new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), yx219, Pos(yx2130), bc) → new_map1(yx207, yx212000, yx2180, bc) we obtained the following new rules:

new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                                    ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, yx218, yx212, Zero, Neg(Succ(Zero)), bc) → new_map17(yx207, yx217, yx218, yx212, bc) we obtained the following new rules:

new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                                        ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map7(yx252, yx258, bb) → new_map4(Pos(Zero), yx252, yx252, yx258, yx252, bb) we obtained the following new rules:

new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
QDP
                                                                                                                                                            ↳ DependencyGraphProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Zero), yx249, yx250, Neg(yx2370), Zero, bb) → new_map1(Pos(Zero), yx250, yx2370, bb)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Pos(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map5(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb) we obtained the following new rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
QDP
                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ UsableRulesProof
QDP
                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1) at position [0] we obtained the following new rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Rewriting
QDP
                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)
new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1) at position [1] we obtained the following new rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), Succ(Zero), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Rewriting
QDP
                                                                                                                                                                                  ↳ UsableRulesProof
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), Succ(Zero), z1)
new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ UsableRulesProof
QDP
                                                                                                                                                                                      ↳ QReductionProof
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), Succ(Zero), z1)
new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)

R is empty.
The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ UsableRulesProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ QReductionProof
QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), Succ(Zero), z1)
new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map5(yx253, yx252, bb) → new_map7(yx252, Pos(Succ(Zero)), bb) we obtained the following new rules:

new_map5(Succ(Zero), Succ(Zero), z0) → new_map7(Succ(Zero), Pos(Succ(Zero)), z0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ UsableRulesProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ QReductionProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
QDP
                                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), Succ(Zero), z1)
new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map5(Succ(Zero), Succ(Zero), z0) → new_map7(Succ(Zero), Pos(Succ(Zero)), z0)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map7(z1, Pos(Succ(Zero)), z2) → new_map4(Pos(Zero), z1, z1, Pos(Succ(Zero)), z1, z2) we obtained the following new rules:

new_map7(Succ(Zero), Pos(Succ(Zero)), z0) → new_map4(Pos(Zero), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), z0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ UsableRulesProof
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ QReductionProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Instantiation
QDP
                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map5(Succ(Zero), Succ(Zero), z1)
new_map7(Succ(Zero), Pos(Succ(Zero)), z0) → new_map4(Pos(Zero), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), z0)
new_map5(Succ(Zero), Succ(Zero), z0) → new_map7(Succ(Zero), Pos(Succ(Zero)), z0)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 3 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
QDP
                                                                                                                                                                  ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Pos(Succ(yx19900)), yx249, yx250, yx237, Zero, bb) → new_map(yx19900, yx249, yx250, yx237, Zero, Succ(yx19900), bb) we obtained the following new rules:

new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
QDP
                                                                                                                                                                      ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map12(yx207, yx218, yx234, bc) → new_map13(yx207, yx218, yx218, yx234, yx218, yx207, bc) we obtained the following new rules:

new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
QDP
                                                                                                                                                                          ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, yx218, yx212, yx219, Neg(Zero), bc) → new_map16(yx207, yx217, yx218, yx212, bc) we obtained the following new rules:

new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
QDP
                                                                                                                                                                              ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map8(yx207, yx212000, yx238, bc) → new_map4(yx207, Succ(yx212000), Succ(yx212000), yx238, Succ(yx212000), bc) we obtained the following new rules:

new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
QDP
                                                                                                                                                                                  ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map3(yx272, yx278, yx280, ba) → new_map4(Pos(Succ(yx272)), yx278, yx278, yx280, yx278, ba) we obtained the following new rules:

new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
QDP
                                                                                                                                                                                      ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Pos(Succ(z0)), Succ(x4), Succ(x4), z2, Succ(x4), z3) → new_map(z0, Succ(x4), Succ(x4), z2, x4, z0, z3) we obtained the following new rules:

new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
QDP
                                                                                                                                                                                          ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Neg(Zero), yx249, yx250, Pos(yx2370), Zero, bb) → new_map6(new_primPlusNat0(yx250, yx2370), new_primPlusNat0(yx250, yx2370), bb) we obtained the following new rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)
new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
QDP
                                                                                                                                                                                              ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1) at position [0] we obtained the following new rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
QDP
                                                                                                                                                                                                  ↳ Rewriting
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1) at position [1] we obtained the following new rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
QDP
                                                                                                                                                                                                      ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map19(yx254, yx259, bb) → new_map4(Neg(Zero), yx254, yx254, yx259, yx254, bb) we obtained the following new rules:

new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map4(Neg(Zero), Zero, Zero, Neg(x2), Zero, z2) → new_map1(Neg(Zero), Zero, x2, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)
new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)
new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Neg(Zero), Zero, Zero, Pos(x2), Zero, z2) → new_map6(new_primPlusNat0(Zero, x2), new_primPlusNat0(Zero, x2), z2) we obtained the following new rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)
new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
QDP
                                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(new_primPlusNat0(Zero, Succ(Zero)), new_primPlusNat0(Zero, Succ(Zero)), z1) at position [0] we obtained the following new rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Rewriting
QDP
                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), new_primPlusNat0(Zero, Succ(Zero)), z1) at position [1] we obtained the following new rules:

new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Rewriting
QDP
                                                                                                                                                                                                                                    ↳ UsableRulesProof
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ UsableRulesProof
QDP
                                                                                                                                                                                                                                        ↳ QReductionProof
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)

R is empty.
The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ UsableRulesProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ QReductionProof
QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map6(yx255, yx254, bb) → new_map19(yx254, Pos(Succ(Zero)), bb) we obtained the following new rules:

new_map6(Succ(Zero), Succ(Zero), z0) → new_map19(Succ(Zero), Pos(Succ(Zero)), z0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ UsableRulesProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ QReductionProof
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2)
new_map6(Succ(Zero), Succ(Zero), z0) → new_map19(Succ(Zero), Pos(Succ(Zero)), z0)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map19(z1, Pos(Succ(Zero)), z2) → new_map4(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, z2) we obtained the following new rules:

new_map19(Succ(Zero), Pos(Succ(Zero)), z0) → new_map4(Neg(Zero), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), z0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ UsableRulesProof
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ UsableRulesProof
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Rewriting
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ Rewriting
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ UsableRulesProof
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ QReductionProof
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                                                                                                                                    ↳ DependencyGraphProof
                                                                                                                                                                                                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map19(Succ(Zero), Pos(Succ(Zero)), z0) → new_map4(Neg(Zero), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), z0)
new_map4(Neg(Zero), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map6(Succ(Zero), Succ(Zero), z1)
new_map6(Succ(Zero), Succ(Zero), z0) → new_map19(Succ(Zero), Pos(Succ(Zero)), z0)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 3 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
QDP
                                                                                                                                                                                                                ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map9(yx207, yx2180, bc) we obtained the following new rules:

new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                                                                                                    ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, yx218, yx212, Succ(yx2190), Neg(Succ(Zero)), bc) → new_map16(yx207, yx217, yx218, yx212, bc) we obtained the following new rules:

new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                                                                                                        ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map4(Pos(Succ(z0)), Zero, Zero, z2, Zero, z3) → new_map(z0, Zero, Zero, z2, Zero, Succ(z0), z3) we obtained the following new rules:

new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
QDP
                                                                                                                                                                                                                            ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map14(yx207, yx218, Zero, yx232, bc) → new_map13(yx207, yx218, yx218, yx232, yx218, yx207, bc) we obtained the following new rules:

new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Pos(x5), Succ(x2), Succ(x2), Pos(Succ(Succ(x3))), Succ(x2), Pos(x5), z3) → new_map1(Pos(x5), x3, x2, z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(yx207, yx217, yx218, Pos(Zero), yx219, Pos(yx2130), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x5), z1, z1, Neg(x3), z1, Pos(x5), z3) → new_map14(Pos(x5), z1, x3, Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map13(Pos(x4), Zero, Zero, Pos(Succ(Succ(x2))), Zero, Pos(x4), z3) → new_map8(Pos(x4), x2, Pos(Succ(Zero)), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(yx207, yx217, Zero, Pos(Succ(Zero)), yx219, Pos(yx2130), bc) → new_map10(yx207, Pos(Succ(Zero)), bc) we obtained the following new rules:

new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Succ(x5))), z3) → new_map15(Neg(Succ(Succ(x5))), Succ(x4), Succ(x4), z2, x5, x4, z3) we obtained the following new rules:

new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, Succ(y_2), Neg(Succ(Succ(x5))), z4) → new_map15(Neg(Succ(Succ(x5))), Succ(y_0), Succ(y_1), z3, x5, y_2, z4) we obtained the following new rules:

new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Succ(Zero)), Zero, Zero, z2, Zero, Neg(Succ(Zero)), z3) → new_map17(Neg(Succ(Zero)), Zero, Zero, z2, z3) we obtained the following new rules:

new_map13(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), Zero, Neg(Succ(Zero)), z2) → new_map17(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map13(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), Zero, Neg(Succ(Zero)), z2) → new_map17(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Zero), z1, z1, z2, z1, Neg(Zero), z3) → new_map16(Neg(Zero), z1, z1, z2, z3) we obtained the following new rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3)
new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), Zero, Neg(Succ(Zero)), z2) → new_map17(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), z2)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, Succ(x4), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), z2, z3) we obtained the following new rules:

new_map13(Neg(Succ(Zero)), Succ(x0), Succ(x0), Pos(Succ(Zero)), Succ(x0), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x0), Succ(x0), Pos(Succ(Zero)), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map13(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), Zero, Neg(Succ(Zero)), z2) → new_map17(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), z2)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_map(yx272, yx273, yx274, Neg(yx2750), Zero, Succ(yx2770), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
new_map16(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, yx218, Neg(yx2120), bc) → new_map14(yx207, yx218, yx2120, Pos(Succ(Zero)), bc)
new_map2(yx272, yx273, yx274, Neg(yx2750), ba) → new_map1(Pos(Succ(yx272)), yx274, yx2750, ba)
The remaining pairs can at least be oriented weakly.

new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map13(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), Zero, Neg(Succ(Zero)), z2) → new_map17(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), z2)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 1   
POL(Pos(x1)) = 0   
POL(Succ(x1)) = 0   
POL(Zero) = 0   
POL(new_map(x1, x2, x3, x4, x5, x6, x7)) = x2 + x4   
POL(new_map0(x1, x2, x3, x4)) = 0   
POL(new_map1(x1, x2, x3, x4)) = 0   
POL(new_map10(x1, x2, x3)) = 0   
POL(new_map12(x1, x2, x3, x4)) = 0   
POL(new_map13(x1, x2, x3, x4, x5, x6, x7)) = 0   
POL(new_map14(x1, x2, x3, x4, x5)) = 0   
POL(new_map15(x1, x2, x3, x4, x5, x6, x7)) = x2 + x3 + x4   
POL(new_map16(x1, x2, x3, x4, x5)) = x4   
POL(new_map17(x1, x2, x3, x4, x5)) = x4   
POL(new_map2(x1, x2, x3, x4, x5)) = x4   
POL(new_map3(x1, x2, x3, x4)) = 0   
POL(new_map4(x1, x2, x3, x4, x5, x6)) = 0   
POL(new_map8(x1, x2, x3, x4)) = 0   
POL(new_map9(x1, x2, x3)) = 0   
POL(new_primPlusNat0(x1, x2)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Pos(x3), Zero, Zero, Pos(Succ(Zero)), Zero, Pos(x3), z2) → new_map10(Pos(x3), Pos(Succ(Zero)), z2)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map10(z0, Pos(Succ(Zero)), z2) → new_map4(z0, Zero, Zero, Pos(Succ(Zero)), Zero, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map17(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), Zero, Neg(Succ(Zero)), z2) → new_map17(Neg(Succ(Zero)), Zero, Zero, Pos(Succ(Zero)), z2)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map14(z0, z2, Succ(x2), Pos(Succ(Zero)), z6) → new_map13(z0, Succ(new_primPlusNat0(z2, x2)), Succ(new_primPlusNat0(z2, x2)), Pos(Succ(Zero)), Succ(new_primPlusNat0(z2, x2)), z0, z6)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map8(z0, z1, Pos(Succ(Zero)), z2) → new_map4(z0, Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map16(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map14(z0, z2, Zero, Pos(Succ(Zero)), z4) → new_map13(z0, z2, z2, Pos(Succ(Zero)), z2, z0, z4)
new_map14(Pos(z0), z1, Zero, Pos(Succ(Zero)), z3) → new_map13(Pos(z0), z1, z1, Pos(Succ(Zero)), z1, Pos(z0), z3)
new_map16(yx207, yx217, Zero, Pos(Succ(Zero)), bc) → new_map10(yx207, Pos(Succ(Zero)), bc)
new_map17(yx207, yx217, Zero, Pos(Succ(Succ(yx212000))), bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Zero, bc) → new_map8(yx207, yx212000, Pos(Succ(Zero)), bc)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map8(Pos(z0), z1, Pos(Succ(Zero)), z2) → new_map4(Pos(z0), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Zero, Zero, bc) → new_map10(yx207, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 14 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_map4(Pos(Succ(x0)), Zero, Zero, Pos(Succ(Zero)), Zero, z1) → new_map(x0, Zero, Zero, Pos(Succ(Zero)), Zero, Succ(x0), z1)
The remaining pairs can at least be oriented weakly.

new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
Used ordering: Polynomial interpretation [25]:

POL(Pos(x1)) = x1   
POL(Succ(x1)) = 0   
POL(Zero) = 1   
POL(new_map(x1, x2, x3, x4, x5, x6, x7)) = x4   
POL(new_map0(x1, x2, x3, x4)) = x3   
POL(new_map2(x1, x2, x3, x4, x5)) = x4   
POL(new_map3(x1, x2, x3, x4)) = x2   
POL(new_map4(x1, x2, x3, x4, x5, x6)) = x3   
POL(new_primPlusNat0(x1, x2)) = x2   

The following usable rules [17] were oriented:

new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables Pos(Succ(Zero)) is replaced by the fresh variable x_removed.
Pair: new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
Positions in right side of the pair: Pair: new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
Positions in right side of the pair: Pair: new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
Positions in right side of the pair: The new variable was added to all pairs as a new argument[13].

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map0(yx272, yx279, yx278, ba, x_removed) → new_map3(yx272, yx278, x_removed, ba, x_removed)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba, x_removed) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba, x_removed)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2, x_removed) → new_map(x0, Succ(z1), Succ(z1), x_removed, z1, x0, z2, x_removed)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba, x_removed) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba, x_removed)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba, x_removed) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba, x_removed)
new_map3(z0, z2, Pos(Succ(Zero)), z3, x_removed) → new_map4(Pos(Succ(z0)), z2, z2, x_removed, z2, z3, x_removed)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba, x_removed) → new_map2(yx272, yx273, yx274, yx275, ba, x_removed)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables Pos(Succ(Zero)) is replaced by the fresh variable x_removed.
Pair: new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2)
Positions in right side of the pair: Pair: new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
Positions in right side of the pair: Pair: new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
Positions in right side of the pair: The new variable was added to all pairs as a new argument[13].

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
QDP
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map0(yx272, yx279, yx278, ba, x_removed) → new_map3(yx272, yx278, x_removed, ba, x_removed)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba, x_removed) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba, x_removed)
new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2, x_removed) → new_map(x0, Succ(z1), Succ(z1), x_removed, z1, x0, z2, x_removed)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba, x_removed) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba, x_removed)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba, x_removed) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba, x_removed)
new_map3(z0, z2, Pos(Succ(Zero)), z3, x_removed) → new_map4(Pos(Succ(z0)), z2, z2, x_removed, z2, z3, x_removed)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba, x_removed) → new_map2(yx272, yx273, yx274, yx275, ba, x_removed)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map4(Pos(Succ(x0)), Succ(z1), Succ(z1), Pos(Succ(Zero)), Succ(z1), z2) → new_map(x0, Succ(z1), Succ(z1), Pos(Succ(Zero)), z1, x0, z2) we obtained the following new rules:

new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map3(z0, z2, Pos(Succ(Zero)), z3) → new_map4(Pos(Succ(z0)), z2, z2, Pos(Succ(Zero)), z2, z3) we obtained the following new rules:

new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map(yx272, yx273, yx274, yx275, Succ(yx2760), Succ(yx2770), ba) → new_map(yx272, yx273, yx274, yx275, yx2760, yx2770, ba) we obtained the following new rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map0(yx272, yx279, yx278, ba) → new_map3(yx272, yx278, Pos(Succ(Zero)), ba) we obtained the following new rules:

new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule new_map(yx272, yx273, yx274, Pos(yx2750), Zero, Succ(yx2770), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba) at position [2] we obtained the following new rules:

new_map(y0, y1, Zero, Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Zero, Zero), Zero, y5)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y5)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y5)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(y0, y1, Zero, Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Zero, Zero), Zero, y5)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y5)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y5)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y5)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y5) at position [1] we obtained the following new rules:

new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y5)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y5) at position [1] we obtained the following new rules:

new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y5)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y5) at position [1] we obtained the following new rules:

new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule new_map2(yx272, yx273, yx274, Pos(yx2750), ba) → new_map0(yx272, new_primPlusNat0(yx274, yx2750), new_primPlusNat0(yx274, yx2750), ba) at position [2] we obtained the following new rules:

new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y4)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y4)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map2(y0, y1, Zero, Pos(Zero), y4) → new_map0(y0, new_primPlusNat0(Zero, Zero), Zero, y4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y4)
new_map2(y0, y1, Zero, Pos(Zero), y4) → new_map0(y0, new_primPlusNat0(Zero, Zero), Zero, y4)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y4)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Zero), Succ(x0), y4) at position [1] we obtained the following new rules:

new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y4)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, new_primPlusNat0(Zero, Succ(x0)), Succ(x0), y4) at position [1] we obtained the following new rules:

new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, new_primPlusNat0(Succ(x0), Succ(x1)), Succ(Succ(new_primPlusNat0(x0, x1))), y4) at position [1] we obtained the following new rules:

new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map0(Succ(y_0), x1, Succ(Succ(y_1)), x3) → new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x3) we obtained the following new rules:

new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map0(Succ(y_0), x1, Succ(Zero), x3) → new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x3) we obtained the following new rules:

new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map0(Zero, x1, Succ(Zero), x3) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x3) we obtained the following new rules:

new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map(y0, y1, Zero, Pos(Succ(x0)), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5) we obtained the following new rules:

new_map(Zero, x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(Succ(y_0), x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Zero, x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map(yx272, yx273, yx274, yx275, Zero, Zero, ba) → new_map2(yx272, yx273, yx274, yx275, ba) we obtained the following new rules:

new_map(x0, x1, Succ(y_2), Pos(Zero), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Zero), x4)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map(x0, x1, Zero, Pos(Succ(y_2)), Zero, Zero, x4) → new_map2(x0, x1, Zero, Pos(Succ(y_2)), x4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, Succ(y_2), Pos(Zero), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Zero), x4)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map(x0, x1, Zero, Pos(Succ(y_2)), Zero, Zero, x4) → new_map2(x0, x1, Zero, Pos(Succ(y_2)), x4)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Zero, x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map(y0, y1, Succ(x0), Pos(Zero), Zero, Succ(y4), y5) → new_map0(y0, Succ(x0), Succ(x0), y5) we obtained the following new rules:

new_map(Succ(y_0), x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(Zero, x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, Succ(y_2), Pos(Zero), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Zero), x4)
new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map(x0, x1, Zero, Pos(Succ(y_2)), Zero, Zero, x4) → new_map2(x0, x1, Zero, Pos(Succ(y_2)), x4)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(Zero, x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(Succ(y_0), x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(Zero, x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map2(y0, y1, Succ(x0), Pos(Zero), y4) → new_map0(y0, Succ(x0), Succ(x0), y4) we obtained the following new rules:

new_map2(Zero, x1, Succ(Zero), Pos(Zero), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map2(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map2(Succ(y_0), x1, Succ(Zero), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map2(Zero, x1, Succ(Zero), Pos(Zero), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map(x0, x1, Succ(y_2), Pos(Zero), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Zero), x4)
new_map2(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map2(Succ(y_0), x1, Succ(Zero), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map(x0, x1, Zero, Pos(Succ(y_2)), Zero, Zero, x4) → new_map2(x0, x1, Zero, Pos(Succ(y_2)), x4)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Zero, x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(Succ(y_0), x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(Zero, x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule new_map2(y0, y1, Zero, Pos(Succ(x0)), y4) → new_map0(y0, Succ(x0), Succ(x0), y4) we obtained the following new rules:

new_map2(Succ(y_0), x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map2(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map2(Zero, x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, Succ(y_2), Pos(Zero), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Zero), x4)
new_map2(Zero, x1, Succ(Zero), Pos(Zero), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map2(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map2(Zero, x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map(x0, x1, Zero, Pos(Succ(y_2)), Zero, Zero, x4) → new_map2(x0, x1, Zero, Pos(Succ(y_2)), x4)
new_map2(Succ(y_0), x1, Succ(Zero), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(Zero, x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map2(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(Succ(y_0), x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(Succ(y_0), x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(Zero, x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_map(x0, x1, Succ(y_2), Pos(Zero), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Zero), x4)
new_map(x0, x1, Zero, Pos(Succ(y_2)), Zero, Zero, x4) → new_map2(x0, x1, Zero, Pos(Succ(y_2)), x4)
new_map(Zero, x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Zero)), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x4)
new_map(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x4)
new_map(Zero, x1, Succ(Zero), Pos(Zero), Zero, Succ(x3), x4) → new_map0(Zero, Succ(Zero), Succ(Zero), x4)
The remaining pairs can at least be oriented weakly.

new_map2(Zero, x1, Succ(Zero), Pos(Zero), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map2(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map2(Zero, x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map2(Succ(y_0), x1, Succ(Zero), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map2(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(Succ(y_0), x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)
Used ordering: Polynomial interpretation [25]:

POL(Pos(x1)) = x1   
POL(Succ(x1)) = 0   
POL(Zero) = 1   
POL(new_map(x1, x2, x3, x4, x5, x6, x7)) = x2 + x3 + x4   
POL(new_map0(x1, x2, x3, x4)) = 0   
POL(new_map2(x1, x2, x3, x4, x5)) = x2   
POL(new_map3(x1, x2, x3, x4)) = 0   
POL(new_map4(x1, x2, x3, x4, x5, x6)) = 0   
POL(new_primPlusNat0(x1, x2)) = 1 + x2   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map2(Zero, x1, Succ(Zero), Pos(Zero), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map2(Succ(y_0), x1, Zero, Pos(Succ(Succ(y_1))), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map3(Succ(y_0), Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map2(Succ(y_0), x1, Succ(Succ(y_1)), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Succ(y_1)), Succ(Succ(y_1)), x3)
new_map0(Succ(x0), Succ(Zero), Succ(Zero), z4) → new_map3(Succ(x0), Succ(Zero), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(Zero, x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Zero, Succ(Zero), Succ(Zero), x3)
new_map0(Zero, Succ(Zero), Succ(Zero), z4) → new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), z4)
new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Zero, Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Zero, x2)
new_map2(Succ(y_0), x1, Zero, Pos(Succ(Zero)), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map3(Zero, Succ(Zero), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Zero)), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map2(Succ(y_0), x1, Succ(Zero), Pos(Zero), x3) → new_map0(Succ(y_0), Succ(Zero), Succ(Zero), x3)
new_map4(Pos(Succ(Succ(y_4))), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Succ(Zero), x2) → new_map(Succ(y_4), Succ(Zero), Succ(Zero), Pos(Succ(Zero)), Zero, Succ(y_4), x2)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 12 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                                                                                                                          ↳ MNOCProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables Pos(Succ(Zero)) is replaced by the fresh variable x_removed.
Pair: new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
Positions in right side of the pair: Pair: new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
Positions in right side of the pair: Pair: new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
Positions in right side of the pair: Pair: new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
Positions in right side of the pair: The new variable was added to all pairs as a new argument[13].

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                                                                                                                          ↳ MNOCProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4, x_removed) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4, x_removed)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2, x_removed) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), x_removed, Succ(y_4), Succ(y_5), x2, x_removed)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5, x_removed) → new_map3(Succ(x0), Succ(Succ(y_1)), x_removed, z5, x_removed)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4, x_removed) → new_map3(Succ(x0), Succ(Succ(x2)), x_removed, z4, x_removed)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4, x_removed) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4, x_removed)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5, x_removed) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5, x_removed)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6, x_removed) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6, x_removed)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6, x_removed) → new_map(x0, x1, x2, x3, Zero, Zero, x6, x_removed)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2, x_removed) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), x_removed, Succ(Succ(y_1)), x2, x_removed)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6, x_removed) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6, x_removed)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables Pos(Succ(Zero)) is replaced by the fresh variable x_removed.
Pair: new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
Positions in right side of the pair: Pair: new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
Positions in right side of the pair: Pair: new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
Positions in right side of the pair: Pair: new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
Positions in right side of the pair: The new variable was added to all pairs as a new argument[13].

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ MNOCProof
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4, x_removed) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4, x_removed)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2, x_removed) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), x_removed, Succ(y_4), Succ(y_5), x2, x_removed)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5, x_removed) → new_map3(Succ(x0), Succ(Succ(y_1)), x_removed, z5, x_removed)
new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4, x_removed) → new_map3(Succ(x0), Succ(Succ(x2)), x_removed, z4, x_removed)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4, x_removed) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4, x_removed)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5, x_removed) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5, x_removed)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6, x_removed) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6, x_removed)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6, x_removed) → new_map(x0, x1, x2, x3, Zero, Zero, x6, x_removed)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2, x_removed) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), x_removed, Succ(Succ(y_1)), x2, x_removed)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6, x_removed) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6, x_removed)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [17] to decrease Q to the empty set.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ QDPOrderProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                              ↳ Narrowing
                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                  ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                      ↳ Rewriting
                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                          ↳ Rewriting
                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                  ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                      ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                          ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                                                                                              ↳ ForwardInstantiation
                                                                                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
                                                                                                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                                                                                                                          ↳ RemovalProof
                                                                                                                                                                                                                                                                                                                                                                          ↳ MNOCProof
QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map0(Succ(x0), Succ(Succ(x2)), Succ(Succ(x2)), z4) → new_map3(Succ(x0), Succ(Succ(x2)), Pos(Succ(Zero)), z4)
new_map(x0, x1, x2, Pos(y_3), Succ(Zero), Succ(Succ(y_4)), x6) → new_map(x0, x1, x2, Pos(y_3), Zero, Succ(y_4), x6)
new_map(y0, y1, Succ(x0), Pos(Succ(x1)), Zero, Succ(y4), y5) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y5)
new_map(x0, x1, x2, x3, Succ(Succ(y_4)), Succ(Succ(y_5)), x6) → new_map(x0, x1, x2, x3, Succ(y_4), Succ(y_5), x6)
new_map0(Succ(x0), Succ(Succ(y_0)), Succ(Succ(y_1)), z5) → new_map3(Succ(x0), Succ(Succ(y_1)), Pos(Succ(Zero)), z5)
new_map4(Pos(Succ(Succ(y_5))), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(Succ(y_4)), x2) → new_map(Succ(y_5), Succ(Succ(y_4)), Succ(Succ(y_4)), Pos(Succ(Zero)), Succ(y_4), Succ(y_5), x2)
new_map(x0, x1, Succ(y_2), Pos(Succ(y_3)), Zero, Zero, x4) → new_map2(x0, x1, Succ(y_2), Pos(Succ(y_3)), x4)
new_map3(Succ(y_0), Succ(Succ(y_1)), Pos(Succ(Zero)), x2) → new_map4(Pos(Succ(Succ(y_0))), Succ(Succ(y_1)), Succ(Succ(y_1)), Pos(Succ(Zero)), Succ(Succ(y_1)), x2)
new_map(x0, x1, x2, x3, Succ(Zero), Succ(Zero), x6) → new_map(x0, x1, x2, x3, Zero, Zero, x6)
new_map2(y0, y1, Succ(x0), Pos(Succ(x1)), y4) → new_map0(y0, Succ(Succ(new_primPlusNat0(x0, x1))), Succ(Succ(new_primPlusNat0(x0, x1))), y4)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

Q is empty.
We have to consider all (P,Q,R)-chains.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

The TRS R consists of the following rules:

new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yx2180), Zero) → Succ(yx2180)
new_primPlusNat0(Zero, Succ(yx212000)) → Succ(yx212000)
new_primPlusNat0(Succ(yx2180), Succ(yx212000)) → Succ(Succ(new_primPlusNat0(yx2180, yx212000)))

The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
The set Q consists of the following terms:

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_primPlusNat0(Zero, Succ(x0))
new_primPlusNat0(Zero, Zero)
new_primPlusNat0(Succ(x0), Zero)
new_primPlusNat0(Succ(x0), Succ(x1))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
QDP
                                                                                                                                                                                                                                                                              ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Zero)), z3) → new_map16(Neg(Succ(Zero)), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3) we obtained the following new rules:

new_map13(Neg(Succ(Zero)), Succ(x0), Succ(x0), Pos(Succ(Zero)), Succ(x0), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x0), Succ(x0), Pos(Succ(Zero)), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                                  ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), z3) we obtained the following new rules:

new_map13(Neg(Zero), Succ(x0), Succ(x0), Pos(Succ(Zero)), Succ(x0), Neg(Zero), z2) → new_map16(Neg(Zero), Succ(x0), Succ(x0), Pos(Succ(Zero)), z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                                      ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Pos(x4), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Pos(x4), z3) → new_map9(Pos(x4), y_1, z3) we obtained the following new rules:

new_map13(Pos(x0), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Pos(x0), z2) → new_map9(Pos(x0), x1, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                                          ↳ Instantiation
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map13(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), Succ(y_2), Neg(Succ(Succ(x0))), z3) → new_map15(Neg(Succ(Succ(x0))), Succ(y_0), Succ(y_1), Pos(Succ(Zero)), x0, y_2, z3) we obtained the following new rules:

new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Instantiation
QDP
                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_map16(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
The remaining pairs can at least be oriented weakly.

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 0   
POL(Pos(x1)) = x1   
POL(Succ(x1)) = 0   
POL(Zero) = 1   
POL(new_map1(x1, x2, x3, x4)) = x1   
POL(new_map12(x1, x2, x3, x4)) = 0   
POL(new_map13(x1, x2, x3, x4, x5, x6, x7)) = 0   
POL(new_map15(x1, x2, x3, x4, x5, x6, x7)) = x1 + x2 + x3 + x4   
POL(new_map16(x1, x2, x3, x4, x5)) = x1 + x4   
POL(new_map17(x1, x2, x3, x4, x5)) = x1   
POL(new_map9(x1, x2, x3)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof
QDP
                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_map17(yx207, yx217, yx218, Pos(Zero), bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
The remaining pairs can at least be oriented weakly.

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)
Used ordering: Polynomial interpretation [25]:

POL(Neg(x1)) = 0   
POL(Pos(x1)) = x1   
POL(Succ(x1)) = 0   
POL(Zero) = 1   
POL(new_map1(x1, x2, x3, x4)) = 0   
POL(new_map12(x1, x2, x3, x4)) = 0   
POL(new_map13(x1, x2, x3, x4, x5, x6, x7)) = 0   
POL(new_map15(x1, x2, x3, x4, x5, x6, x7)) = x4   
POL(new_map16(x1, x2, x3, x4, x5)) = 0   
POL(new_map17(x1, x2, x3, x4, x5)) = x4   
POL(new_map9(x1, x2, x3)) = 0   

The following usable rules [17] were oriented: none



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ DependencyGraphProof
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ Rewriting
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Rewriting
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ Rewriting
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ Rewriting
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ UsableRulesProof
                                                                                                              ↳ QDP
                                                                                                                ↳ QReductionProof
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Instantiation
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Instantiation
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Instantiation
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Instantiation
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ Instantiation
                                                                                                                                      ↳ QDP
                                                                                                                                        ↳ Instantiation
                                                                                                                                          ↳ QDP
                                                                                                                                            ↳ Instantiation
                                                                                                                                              ↳ QDP
                                                                                                                                                ↳ Instantiation
                                                                                                                                                  ↳ QDP
                                                                                                                                                    ↳ Instantiation
                                                                                                                                                      ↳ QDP
                                                                                                                                                        ↳ Instantiation
                                                                                                                                                          ↳ QDP
                                                                                                                                                            ↳ DependencyGraphProof
                                                                                                                                                              ↳ AND
                                                                                                                                                                ↳ QDP
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ Rewriting
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Rewriting
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ DependencyGraphProof
                                                                                                                                                                                                            ↳ AND
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                            ↳ Instantiation
                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                ↳ Instantiation
                                                                                                                                                                                                                                                  ↳ QDP
                                                                                                                                                                                                                                                    ↳ Instantiation
                                                                                                                                                                                                                                                      ↳ QDP
                                                                                                                                                                                                                                                        ↳ Instantiation
                                                                                                                                                                                                                                                          ↳ QDP
                                                                                                                                                                                                                                                            ↳ QDPOrderProof
                                                                                                                                                                                                                                                              ↳ QDP
                                                                                                                                                                                                                                                                ↳ DependencyGraphProof
                                                                                                                                                                                                                                                                  ↳ AND
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                      ↳ UsableRulesProof
                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                          ↳ QReductionProof
                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                              ↳ Instantiation
                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                  ↳ Instantiation
                                                                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                                                                      ↳ Instantiation
                                                                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                                                                          ↳ Instantiation
                                                                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                                                                              ↳ QDPOrderProof
                                                                                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                                                                                  ↳ QDPOrderProof
QDP
                                                                                                                                                                                                                                                                                                      ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map13(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), Succ(y_0), Neg(Zero), z3) → new_map16(Neg(Zero), Succ(y_0), Succ(y_0), Pos(Succ(Zero)), z3)
new_map13(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), Succ(x4), Neg(Succ(Zero)), z2) → new_map16(Neg(Succ(Zero)), Succ(x4), Succ(x4), Pos(Succ(Zero)), z2)
new_map12(z0, z1, Pos(Succ(Zero)), z2) → new_map13(z0, z1, z1, Pos(Succ(Zero)), z1, z0, z2)
new_map15(yx207, yx217, yx218, yx212, Zero, Succ(yx2190), bc) → new_map16(yx207, yx217, yx218, yx212, bc)
new_map15(yx207, yx217, yx218, yx212, Succ(yx213000), Succ(yx2190), bc) → new_map15(yx207, yx217, yx218, yx212, yx213000, yx2190, bc)
new_map13(Pos(x4), Succ(x2), Succ(x2), Pos(Succ(Zero)), Succ(x2), Pos(x4), z2) → new_map9(Pos(x4), x2, z2)
new_map13(Neg(Zero), z1, z1, Pos(Succ(Zero)), z1, Neg(Zero), z2) → new_map16(Neg(Zero), z1, z1, Pos(Succ(Zero)), z2)
new_map1(yx207, Zero, Succ(yx2180), bc) → new_map9(yx207, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map16(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map15(yx207, yx217, yx218, yx212, Zero, Zero, bc) → new_map17(yx207, yx217, yx218, yx212, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Succ(yx212000))), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map13(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), Succ(x1), Neg(Succ(Succ(x0))), z2) → new_map15(Neg(Succ(Succ(x0))), Succ(x1), Succ(x1), Pos(Succ(Zero)), x0, x1, z2)
new_map1(yx207, Succ(yx212000), Succ(yx2180), bc) → new_map1(yx207, yx212000, yx2180, bc)
new_map17(yx207, yx217, Succ(yx2180), Pos(Succ(Zero)), bc) → new_map9(yx207, yx2180, bc)
new_map9(yx207, yx218, bc) → new_map12(yx207, yx218, Pos(Succ(Zero)), bc)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ Rewriting
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, new_fromInt(Pos(Succ(Zero))), ba)
new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, new_fromInt(Pos(Succ(Zero))), ba)
new_map21(yx207, Zero, yx235, ba) → new_map20(yx207, yx235, yx207, ba)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

The TRS R consists of the following rules:

new_fromInt(yx8) → yx8

The set Q consists of the following terms:

new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, new_fromInt(Pos(Succ(Zero))), ba) at position [2] we obtained the following new rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
QDP
                                    ↳ Rewriting
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map21(yx207, Zero, yx235, ba) → new_map20(yx207, yx235, yx207, ba)
new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, new_fromInt(Pos(Succ(Zero))), ba)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

The TRS R consists of the following rules:

new_fromInt(yx8) → yx8

The set Q consists of the following terms:

new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, new_fromInt(Pos(Succ(Zero))), ba) at position [2] we obtained the following new rules:

new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
QDP
                                        ↳ UsableRulesProof
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map21(yx207, Zero, yx235, ba) → new_map20(yx207, yx235, yx207, ba)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba)
new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

The TRS R consists of the following rules:

new_fromInt(yx8) → yx8

The set Q consists of the following terms:

new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
QDP
                                            ↳ QReductionProof
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map21(yx207, Zero, yx235, ba) → new_map20(yx207, yx235, yx207, ba)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba)
new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

R is empty.
The set Q consists of the following terms:

new_fromInt(x0)

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

new_fromInt(x0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QReductionProof
QDP
                                                ↳ Instantiation
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map21(yx207, Zero, yx235, ba) → new_map20(yx207, yx235, yx207, ba)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)
new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map21(yx207, Zero, yx235, ba) → new_map20(yx207, yx235, yx207, ba) we obtained the following new rules:

new_map21(z0, Zero, Pos(Succ(Zero)), z2) → new_map20(z0, Pos(Succ(Zero)), z0, z2)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QReductionProof
                                              ↳ QDP
                                                ↳ Instantiation
QDP
                                                    ↳ DependencyGraphProof
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map21(z0, Zero, Pos(Succ(Zero)), z2) → new_map20(z0, Pos(Succ(Zero)), z0, z2)
new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba)
new_map20(yx207, Neg(yx2120), Pos(Succ(yx21300)), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QReductionProof
                                              ↳ QDP
                                                ↳ Instantiation
                                                  ↳ QDP
                                                    ↳ DependencyGraphProof
QDP
                                                        ↳ Instantiation
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map21(z0, Zero, Pos(Succ(Zero)), z2) → new_map20(z0, Pos(Succ(Zero)), z0, z2)
new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map20(yx207, yx212, Neg(Zero), ba) → new_map23(yx207, yx212, ba) we obtained the following new rules:

new_map20(Neg(Zero), Pos(Succ(Zero)), Neg(Zero), z1) → new_map23(Neg(Zero), Pos(Succ(Zero)), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QReductionProof
                                              ↳ QDP
                                                ↳ Instantiation
                                                  ↳ QDP
                                                    ↳ DependencyGraphProof
                                                      ↳ QDP
                                                        ↳ Instantiation
QDP
                                                            ↳ Instantiation
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map20(Neg(Zero), Pos(Succ(Zero)), Neg(Zero), z1) → new_map23(Neg(Zero), Pos(Succ(Zero)), z1)
new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba)
new_map21(z0, Zero, Pos(Succ(Zero)), z2) → new_map20(z0, Pos(Succ(Zero)), z0, z2)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map23(yx207, yx212, ba) → new_map22(yx207, yx212, ba) we obtained the following new rules:

new_map23(Neg(Zero), Pos(Succ(Zero)), z0) → new_map22(Neg(Zero), Pos(Succ(Zero)), z0)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QReductionProof
                                              ↳ QDP
                                                ↳ Instantiation
                                                  ↳ QDP
                                                    ↳ DependencyGraphProof
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
QDP
                                                                ↳ DependencyGraphProof
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map23(Neg(Zero), Pos(Succ(Zero)), z0) → new_map22(Neg(Zero), Pos(Succ(Zero)), z0)
new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map20(Neg(Zero), Pos(Succ(Zero)), Neg(Zero), z1) → new_map23(Neg(Zero), Pos(Succ(Zero)), z1)
new_map21(z0, Zero, Pos(Succ(Zero)), z2) → new_map20(z0, Pos(Succ(Zero)), z0, z2)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QReductionProof
                                              ↳ QDP
                                                ↳ Instantiation
                                                  ↳ QDP
                                                    ↳ DependencyGraphProof
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ DependencyGraphProof
QDP
                                                                    ↳ Instantiation
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map21(z0, Zero, Pos(Succ(Zero)), z2) → new_map20(z0, Pos(Succ(Zero)), z0, z2)
new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By instantiating [15] the rule new_map20(yx207, yx212, Pos(Zero), ba) → new_map22(yx207, yx212, ba) we obtained the following new rules:

new_map20(Pos(Zero), Pos(Succ(Zero)), Pos(Zero), z1) → new_map22(Pos(Zero), Pos(Succ(Zero)), z1)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ Rewriting
                                      ↳ QDP
                                        ↳ UsableRulesProof
                                          ↳ QDP
                                            ↳ QReductionProof
                                              ↳ QDP
                                                ↳ Instantiation
                                                  ↳ QDP
                                                    ↳ DependencyGraphProof
                                                      ↳ QDP
                                                        ↳ Instantiation
                                                          ↳ QDP
                                                            ↳ Instantiation
                                                              ↳ QDP
                                                                ↳ DependencyGraphProof
                                                                  ↳ QDP
                                                                    ↳ Instantiation
QDP
                                                                        ↳ DependencyGraphProof
                              ↳ QDP
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map22(yx207, Neg(yx2120), ba) → new_map21(yx207, yx2120, Pos(Succ(Zero)), ba)
new_map20(Pos(Zero), Pos(Succ(Zero)), Pos(Zero), z1) → new_map22(Pos(Zero), Pos(Succ(Zero)), z1)
new_map21(z0, Zero, Pos(Succ(Zero)), z2) → new_map20(z0, Pos(Succ(Zero)), z0, z2)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 3 less nodes.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                          ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_map24(yx207, yx208, yx209, Succ(yx2100), Succ(yx2110), yx212, yx213, ba) → new_map24(yx207, yx208, yx209, yx2100, yx2110, yx212, yx213, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:


Haskell To QDPs